package pe.gob.foncodes.ssa.web.controller;

import java.util.ArrayList;
import java.util.List;
import javax.faces.bean.ManagedBean;
import javax.faces.event.ActionEvent;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.log4j.Logger;
import org.primefaces.context.RequestContext;
import org.primefaces.event.RowEditEvent;
import org.primefaces.event.SelectEvent;
import org.primefaces.model.DefaultTreeNode;
import org.primefaces.model.TreeNode;
import pe.gob.foncodes.ssa.bs.administracion.controller.GenericMaintenanceController;
import pe.gob.foncodes.ssa.bs.common.util.Constante;
import pe.gob.foncodes.ssa.bs.common.util.ServiceException;
import pe.gob.foncodes.ssa.bs.seguridad.domain.Accion;
import pe.gob.foncodes.ssa.bs.seguridad.domain.ControlAcceso;
import pe.gob.foncodes.ssa.bs.seguridad.domain.Modulo;
import pe.gob.foncodes.ssa.bs.seguridad.domain.Opcion;
/**
 *
 * @author aespinoza
 */
@ManagedBean(name = "opcionController")
public class OpcionController extends GenericMaintenanceController{
    
    protected static Logger log = Logger.getLogger(OpcionController.class);
    private boolean esNuevo;
    private String txtBusquedaOpcion;
    private String mensaje;
    private TreeNode opcionTree;
    private TreeNode selectedOpcionNode; 
    private boolean BMuestraObs;
    private boolean BActivo;
    private boolean BVisible;
    
    private List<Opcion> lstOpcion = new ArrayList<Opcion>();
    private Opcion selectedOpcion;
    
    private Modulo selectedModuloOpcion;
    
    private List<Opcion> lstOpcionPadre = new ArrayList<Opcion>();
    private Opcion selectedOpcionPadre;
    
    private List<Accion> lstAccion = new ArrayList<Accion>();
    private Accion selectedAccion;
    
    @Override
    public void init() {
        mensaje = "";
        setBean(new Opcion());
        selectedOpcion = null;
        selectedOpcionNode = null;
        esNuevo = false;
        BMuestraObs = false;
    }
    
    @Override
    public void search(ActionEvent event) throws Exception{
        selectedOpcion = null;
        selectedOpcionNode = null;
        listar();
    }
    
    public void listar() throws ServiceException{
        if(this.txtBusquedaOpcion == null){
            this.txtBusquedaOpcion = "";
        }
        if(txtBusquedaOpcion.trim().equals("")){
            lstOpcion = getService().findByNamedQuery("Opcion.findOnlyNidOpcionPadre", new Object[]{selectedModuloOpcion.getId()});
        }else{
            lstOpcion = getService().findByNamedQuery("Opcion.findByTxtOpcion", new Object[]{"%" + txtBusquedaOpcion.trim().toUpperCase() + "%", selectedModuloOpcion.getId()});
        }
        setBeanList(lstOpcion);
        if(selectedOpcion != null){
            opcionTree = new DefaultTreeNode("root", null);
            loadPadreTree(selectedOpcion);
        }
    }
    
    public void onRowSelect(SelectEvent event) {
        opcionTree = new DefaultTreeNode("root", null);
        selectedOpcion = (Opcion) event.getObject();
        try {
            loadPadreTree(selectedOpcion);
        } catch (ServiceException ex) {
            log.error("ERROR EN onRowSelect: "+ex);
        }
    }
    
    public void loadInicialTree(){
        selectedOpcion = null;
        selectedOpcionNode = null;
        opcionTree = new DefaultTreeNode("root", null);
        try {
            List<Opcion> lstOpcionInicial = getService().findByNamedQuery("Opcion.findOnlyNidOpcionPadre", new Object[]{selectedModuloOpcion.getId()});
            lstOpcion = new ArrayList<Opcion>();
            for (Opcion opcion : lstOpcionInicial) {
                lstOpcion.add(opcion);
                TreeNode padre = new DefaultTreeNode(opcion, opcionTree);
            }
            setBeanList(lstOpcion);
        } catch (ServiceException ex) {
            log.error("ERROR EN loadInicialTree: "+ex);
        }
    }
    
    public void loadPadreTree(Opcion selectedOpcion) throws ServiceException {
        TreeNode padre = new DefaultTreeNode(selectedOpcion, opcionTree);
        padre.setExpanded(true);
        selectedOpcionNode = padre;
        
        List<Opcion> lstOpcionHijos = new ArrayList<Opcion>();
        try {
            lstOpcionHijos = getService().findByNamedQuery("Opcion.findByNidOpcionPadre", new Object[]{selectedOpcion.getId(), selectedModuloOpcion.getId()});
            for (Opcion hijoOp : lstOpcionHijos) {
                TreeNode hijo = new DefaultTreeNode(hijoOp, padre);
                hijo.setExpanded(true);
                loadHijoTree(hijo, hijoOp);
            }
        } catch (ServiceException ex) {
            log.error("ERROR EN onRowSelect="+ex);
        }
    }
    
    public void loadHijoTree(TreeNode hijo, Opcion opHijo) throws ServiceException {
        List<Opcion> lstOpcionHijos = getService().findByNamedQuery("Opcion.findByNidOpcionPadre", new Object[]{opHijo.getId(), selectedModuloOpcion.getId()});
        for (Opcion opcion : lstOpcionHijos) {
            TreeNode nieto = new DefaultTreeNode(opcion, hijo);
            nieto.setExpanded(true);
            loadHijoTree(nieto, opcion);
        }
    }
    
    public void muestraObservacion() {  
        BMuestraObs = (BActivo)?false:true;
    }
    
    public void nuevo() {
        RequestContext context = RequestContext.getCurrentInstance();
        BActivo = true;
        esNuevo = true;
        BVisible = true;
        BMuestraObs = false;
        Opcion opcion = new Opcion();
        //opcion.setFecCaducidad(Constante.FECHA_ACTUAL);
        opcion.setNidModulo(selectedModuloOpcion);
        if(selectedOpcionNode != null){
            opcion.setNidOpcionPadre((Opcion) selectedOpcionNode.getData());
        }
        setBean(opcion);
        context.execute("wDetalleOpcion.show()");
    }
    
    @Override
    public void load(ActionEvent event) throws Exception {
        RequestContext context = RequestContext.getCurrentInstance();
        if(selectedOpcionNode == null){
            setMessageError(new Exception("Debe seleccionar una opción del árbol"));
            esNuevo = false;
        }else {
            esNuevo = false;
            Opcion opcion = (Opcion) selectedOpcionNode.getData();
            opcion = (Opcion) getService().findById(Opcion.class, opcion.getId());
            setBean(opcion);
            BActivo = false;
            BVisible = false;
            if(opcion.getFlgActivo() != null){
                if(opcion.getFlgActivo().equals(Constante.ESTADO_ACTIVO)){
                    BActivo = true;
                }else{
                    BActivo = false;
                }
            }
            if(opcion.getFlgVisible() != null){
                if(opcion.getFlgVisible().equals(Constante.ESTADO_ACTIVO)){
                    BVisible = true;
                }else{
                    BVisible = false;
                }
            }
            if(BActivo){
                BMuestraObs = false;
            }else{
                BMuestraObs = true;
            }
            context.execute("wDetalleOpcion.show()");
        }
    }
    
    public void searchOpcionPadre() throws Exception{
        Opcion opcion = (Opcion)getBean();
        Long NidOpcion = opcion.getId();
        lstOpcionPadre = new ArrayList<Opcion>();
        Opcion opcionTmp = null;
        for (TreeNode nodePadre : opcionTree.getChildren()) {
            opcionTmp = (Opcion) nodePadre.getData();
            if(!opcionTmp.getId().equals(NidOpcion)){
                lstOpcionPadre.add(opcionTmp);
            }
            if(!nodePadre.getChildren().isEmpty()){
                if(!opcionTmp.getId().equals(NidOpcion)){
                    lstOpcionPadre = listaHijos(lstOpcionPadre, nodePadre, NidOpcion);
                }
                
            }
        }
        selectedOpcionPadre = null;
    }
    
    public List<Opcion> listaHijos(List<Opcion> lstOpcionPadreTmp, TreeNode nodo, Long NidOpcionPadre){
        Opcion opcionTmp = null;
        for (TreeNode nodeTmp : nodo.getChildren()) {
            opcionTmp = (Opcion) nodeTmp.getData();
            if(!opcionTmp.getId().equals(NidOpcionPadre)){
                lstOpcionPadreTmp.add(opcionTmp);
            }
            if(!nodeTmp.getChildren().isEmpty()){
                if(!opcionTmp.getId().equals(NidOpcionPadre)){
                    lstOpcionPadreTmp = listaHijos(lstOpcionPadreTmp, nodeTmp, NidOpcionPadre);
                }
            }
        }
        return lstOpcionPadreTmp;
    }
    
    public void actualizaOpcionSeleccion(Opcion opcionAct) {
        this.selectedOpcionPadre = opcionAct;
        Opcion opcion = (Opcion)getBean();
        opcion.setNidOpcionPadre(selectedOpcionPadre);
        setBean(opcion);
    }
    
     @Override
    public void clean(ActionEvent event) throws Exception {
        setBean(new Opcion());
    }
    
    @Override
    public boolean validate() throws Exception {
        boolean success = true;
        Opcion opcion = (Opcion)getBean();
        if (opcion.getTxtOpcion() == null ){
            opcion.setTxtOpcion("");
        }
        if(opcion.getTxtOpcion().trim().equals("")) {
            setMessageError(new Exception("Se debe ingresar el nombre."));
            success = false;
            return success;
        }
        if (opcion.getTxtNombreObjeto() == null ){
            opcion.setTxtNombreObjeto("");
        }
        if(opcion.getTxtNombreObjeto().trim().equals("")) {
            setMessageError(new Exception("Se debe ingresar el nombre del objeto."));
            success = false;
            return success;
        }
        
        /*
        if(opcion.getFecCaducidad() == null) {
            setMessageError(new Exception("Se debe ingresar la fecha de caducidad."));
            success = false;
            return success;
        }*/
        /*if (!opcion.getTxtOpcion().equals("")) {
            List listaOpcion = getService().findByObjectDif("Opcion", "txtOpcion", opcion.getTxtOpcion().trim(), opcion.getId());
            if (listaOpcion != null && listaOpcion.size() != 0) {
                setMessageError(new Exception("Ya existe una opcion registrada con el mismo nombre."));
                success = false;
                return success;
            }
        }*/
        
        if(opcion.getFlgActivo().equals(Constante.ESTADO_INACTIVO)) {
            if (opcion.getTxtObservacion() == null ){
                opcion.setTxtObservacion("");
            }
            if(opcion.getTxtObservacion().equals("")){
                setMessageError(new Exception("Se debe ingresar la observación."));
                success = false;
                return success;
            }
        }
        if(opcion.getFlgActivo().equals(Constante.ESTADO_ACTIVO) && !esNuevo) {
            opcion.setTxtObservacion(null);
        }
        return success;
    }
    
    public void saveOpcion(ActionEvent event) throws Exception {
        RequestContext context = RequestContext.getCurrentInstance();
        Opcion opcion = (Opcion)getBean();
        ControlAcceso control = ((ControlAcceso) getSpringBean(Constante.SESSION_ACCESO));
        opcion.setFlgActivo((BActivo)?Constante.ESTADO_ACTIVO:Constante.ESTADO_INACTIVO);
        opcion.setFlgVisible((BVisible)?Constante.ESTADO_ACTIVO:Constante.ESTADO_INACTIVO);
        opcion.setNIdCtrlAccesoWeb(control.getId());
        setBean(opcion);
        Long nIdOpcionPadre = new Long(0);
        if(opcion.getNidOpcionPadre() != null){
            nIdOpcionPadre = opcion.getNidOpcionPadre().getId();
        }
        try {
            //Nuevo
            if(esNuevo){
                if (validate()) {
                    super.beforeSave(event);
                    super.doSaveSinProp(event);
                    afterSave(event);
                    context.execute("wDetalleOpcion.hide()");
                }
            //Modificar
            }else{
                if (validate()) {
                    super.beforeUpdate(event);
                    super.doUpdate(event);
                    afterUpdate(event);
                    context.execute("wDetalleOpcion.hide()");
                    if(getService().validaExistenciaEnPerfilOAutorizacion(opcion.getId(), nIdOpcionPadre, "1")){
                        context.execute("abreConfirmacion()");
                    }
                }
            }
        } catch (Exception e) {
            log.error("ERROR EN saveOpcion: "+e);
        }
    }
    
    @Override
    public void afterSave(ActionEvent event) throws Exception {
        esNuevo = false;
        ControlAcceso control = ((ControlAcceso) getSpringBean(Constante.SESSION_ACCESO));
        Opcion opcion = (Opcion) getBean();
        setMessageSuccess("Se creo la opción " + "'" + opcion.getTxtOpcion() + "'" + " satisfactoriamente.");
        
        //Cuando se crea una opcion, se crea una accion
        Accion accion = new Accion();
        accion.setTxtAccion(opcion.getTxtOpcion());
        accion.setTxtNombreObjeto(opcion.getTxtNombreObjeto());
        accion.setNidOpcion(opcion);
        accion.setFlgActivo(Constante.ESTADO_ACTIVO);
        accion.setFlgDefault(Constante.ESTADO_ACTIVO);
        accion.setTxtUrl(opcion.getTxtUrl());
        accion.setNIdCtrlAccesoWeb(control.getId());
        setBean(accion);
        super.beforeSave(event);
        super.doSaveSinProp(event);
        log.info("End of Transaction: 'Save'");
        //getService().save(accion);
        setBean(opcion);
        log.info("End of Transaction: 'Save'");
    }
    
    
    public void actualizarEnCascada(){
        Opcion opcion = (Opcion)getBean();
        try {
            getService().actualizaEnCascada(opcion.getId(), opcion.getFlgActivo(), "SP_ACTUALIZA_OPCION");
        }  catch (Exception e) {
            log.error("ERROR EN actualizarEnCascada:"+e);
        }
        setMessageSuccess("Se actualizó la opción " + "'" + opcion.getTxtOpcion() + "'" + " en cascada satisfactoriamente.");
    }
    
    public void copiaPropiedades(){
        try {
            BeanUtils.copyProperties(getBeanAuditoria(), getBean());
        } catch (Exception e) {
            log.error(e);
        }
    }
    
    @Override
    public void afterUpdate(ActionEvent event) throws Exception {
        Object bean = getBean();
        ControlAcceso control = ((ControlAcceso) getSpringBean(Constante.SESSION_ACCESO));
        Opcion opcion = (Opcion) getBean();
        setMessageSuccess("Se actualizó la opción " + "'" + opcion.getTxtOpcion() + "'" + " satisfactoriamente.");
        //Accion.findAccionBaseByNidOpcion
        Accion accion = (Accion)getService().findByNamedQueryUniqueRow("Accion.findAccionBaseByNidOpcion", new Object[]{opcion.getId()});
        accion.setTxtAccion(opcion.getTxtOpcion());
        accion.setTxtNombreObjeto(opcion.getTxtNombreObjeto());
        accion.setTxtUrl(opcion.getTxtUrl());
        accion.setFlgActivo(opcion.getFlgActivo());
        accion.setNIdCtrlAccesoWeb(control.getId());
        setBean(accion);
        super.beforeUpdate(event);
        super.doUpdate(event);
        setBean(bean);
        log.info("End of Transaction: 'Update'");
    }
    
    public boolean isBActivo() {
        return BActivo;
    }

    public void setBActivo(boolean BActivo) {
        this.BActivo = BActivo;
    }

    public boolean isBMuestraObs() {
        return BMuestraObs;
    }

    public void setBMuestraObs(boolean BMuestraObs) {
        this.BMuestraObs = BMuestraObs;
    }

    public boolean isEsNuevo() {
        return esNuevo;
    }

    public void setEsNuevo(boolean esNuevo) {
        this.esNuevo = esNuevo;
    }

    public List<Opcion> getLstOpcion() {
        return lstOpcion;
    }

    public void setLstOpcion(List<Opcion> lstOpcion) {
        this.lstOpcion = lstOpcion;
    }

    public String getMensaje() {
        return mensaje;
    }

    public void setMensaje(String mensaje) {
        this.mensaje = mensaje;
    }

    public TreeNode getOpcionTree() {
        return opcionTree;
    }

    public void setOpcionTree(TreeNode opcionTree) {
        this.opcionTree = opcionTree;
    }

    public Opcion getSelectedOpcion() {
        return selectedOpcion;
    }

    public void setSelectedOpcion(Opcion selectedOpcion) {
        this.selectedOpcion = selectedOpcion;
    }

    public TreeNode getSelectedOpcionNode() {
        return selectedOpcionNode;
    }

    public void setSelectedOpcionNode(TreeNode selectedOpcionNode) {
        this.selectedOpcionNode = selectedOpcionNode;
    }

    public String getTxtBusquedaOpcion() {
        return txtBusquedaOpcion;
    }

    public void setTxtBusquedaOpcion(String txtBusquedaOpcion) {
        this.txtBusquedaOpcion = txtBusquedaOpcion;
    }

    public Modulo getSelectedModuloOpcion() {
        return selectedModuloOpcion;
    }

    public void setSelectedModuloOpcion(Modulo selectedModuloOpcion) {
        this.selectedModuloOpcion = selectedModuloOpcion;
    }

    public List<Opcion> getLstOpcionPadre() {
        return lstOpcionPadre;
    }

    public void setLstOpcionPadre(List<Opcion> lstOpcionPadre) {
        this.lstOpcionPadre = lstOpcionPadre;
    }

    public Opcion getSelectedOpcionPadre() {
        return selectedOpcionPadre;
    }

    public void setSelectedOpcionPadre(Opcion selectedOpcionPadre) {
        this.selectedOpcionPadre = selectedOpcionPadre;
    }

    public List<Accion> getLstAccion() {
        return lstAccion;
    }

    public void setLstAccion(List<Accion> lstAccion) {
        this.lstAccion = lstAccion;
    }

    public Accion getSelectedAccion() {
        return selectedAccion;
    }

    public void setSelectedAccion(Accion selectedAccion) {
        this.selectedAccion = selectedAccion;
    }
    
    public void abrirAcciones() {
        RequestContext context = RequestContext.getCurrentInstance();
        if(selectedOpcionNode == null){
            setMessageError(new Exception("Debe seleccionar una opción del árbol"));
        }else {
            Opcion opcion = (Opcion) selectedOpcionNode.getData();
            if(opcion.getFlgActivo().trim().equals(Constante.ESTADO_INACTIVO)){
                setMessageError(new Exception("La opción no se encuentra activa"));
            }else{
                if(selectedOpcionNode.getChildCount() >= 1){
                    setMessageError(new Exception("No se puede configurar acciones de la Opción Padre"));
                }else{
                    List<Opcion> lstOpcionHijos = new ArrayList<Opcion>();
                    try {
                        lstOpcionHijos = getService().findByNamedQuery("Opcion.findByNidOpcionPadre", new Object[]{opcion.getId(), selectedModuloOpcion.getId()});
                    } catch (ServiceException e) {
                        log.error("ERROR EN abrirAcciones ="+e.getMessage());
                    }
                    if(!lstOpcionHijos.isEmpty()){
                        setMessageError(new Exception("No se puede configurar acciones, la opción tiene hijos"));
                    }else{
                        listarAccionesDeOpcion();
                        context.execute("wGestionarAcciones.show()");
                    }
                }
            }
        }
    }
    
    public void listarAccionesDeOpcion(){
        lstAccion = new ArrayList<Accion>();
        try {
            Opcion opcion =(Opcion) selectedOpcionNode.getData();
            lstAccion = getService().findByNamedQuery("Accion.findByNidOpcion", new Object[]{opcion.getId()});
        } catch (Exception e) {
            log.error("ERROR EN listarAccionesDeOpcion :"+e.getMessage());
        }
        selectedAccion = null;
    }
    
    public void onEdit(RowEditEvent event) {  
        try {
            ControlAcceso control = ((ControlAcceso) getSpringBean(Constante.SESSION_ACCESO));
            Accion accion = (Accion)event.getObject();
            accion.setNIdCtrlAccesoWeb(control.getId());
            getService().save(accion);
        } catch (Exception ex) {
            log.error("ERROR EN onEdit="+ex.getMessage());
        }
    }
      
    public void onCancel(RowEditEvent event) {  
  
    }
    
    public void nuevaAccion() throws Exception {
        if(selectedOpcionNode == null){
            setMessageError(new Exception("Debe seleccionar una opción del árbol"));
        }else {
            RequestContext context = RequestContext.getCurrentInstance();
            esNuevo = true;
            BActivo = true;
            selectedAccion = new Accion();
            selectedAccion.setNidOpcion((Opcion)selectedOpcionNode.getData());
            selectedAccion.setFlgActivo(Constante.ESTADO_ACTIVO);
            context.execute("wDetalleAccion.show()");
        }
    }
    
    public void loadAccion() throws Exception {
        RequestContext context = RequestContext.getCurrentInstance();
        if(selectedAccion == null){
            setMessageError(new Exception("Debe seleccionar un registro"));
            esNuevo = false;
        }else {
            if(selectedAccion.getFlgDefault().equals(Constante.ESTADO_ACTIVO)){
                setMessageError(new Exception("No se debe modificar la acción por defecto"));
            }else{
                esNuevo = false;
                selectedAccion = (Accion) getService().findById(Accion.class, selectedAccion.getId());
                BActivo = false;
                if(selectedAccion.getFlgActivo() != null){
                    if(selectedAccion.getFlgActivo().equals(Constante.ESTADO_ACTIVO)){
                        BActivo = true;
                    }else{
                        BActivo = false;
                    }
                }
                context.execute("wDetalleAccion.show()");
            }
        }
    }
    
    public void saveAccion(ActionEvent event) throws Exception {
        RequestContext context = RequestContext.getCurrentInstance();
        ControlAcceso control = ((ControlAcceso) getSpringBean(Constante.SESSION_ACCESO));
        selectedAccion.setFlgActivo((BActivo)?Constante.ESTADO_ACTIVO:Constante.ESTADO_INACTIVO);
        selectedAccion.setNIdCtrlAccesoWeb(control.getId());
        Object bean = getBean();
        try {
            //Nuevo
            if(esNuevo){
                if (validateAccion()) {
                    selectedAccion.setFlgDefault(Constante.ESTADO_INACTIVO);
                    setBean(selectedAccion);
                    super.beforeSave(event);
                    super.doSaveSinProp(event);
                    setBeanBusqueda(getBean());
                    afterSaveAccion(event);
                    context.execute("wDetalleAccion.hide()");
                    if(getService().validaExistenciaEnPerfilOAutorizacion(selectedAccion.getId(), selectedAccion.getNidOpcion().getId(), "2")){
                        context.execute("abreConfirmacionAccion()");
                    }
                }
            //Modificar
            }else{
                if (validateAccion()) {
                    setBean(selectedAccion);
                    super.beforeUpdate(event);
                    super.doUpdate(event);
                    setBeanBusqueda(getBean());
                    //getService().save(selectedAccion);
                    afterUpdateAccion(event);
                    context.execute("wDetalleAccion.hide()");
                    if(getService().validaExistenciaEnPerfilOAutorizacion(selectedAccion.getId(), selectedAccion.getNidOpcion().getId(), "2")){
                        context.execute("abreConfirmacionAccion()");
                    }
                }
            }
        } catch (Exception e) {
            log.error(e);
        }
        setBean(bean);
    }
    
     public void actualizarAccionEnCascada(){
        Accion accion = (Accion)getBeanBusqueda();
        try {
            if(esNuevo){
                getService().agregaEnCascada(accion.getNidOpcion().getId() ,accion.getId(), accion.getNIdCtrlAccesoWeb(), accion.getFlgActivo(), "SP_AGREGA_ACCIONENUSUPERFIL");
            }else{
                getService().actualizaEnCascada(accion.getId(), accion.getFlgActivo(), "SP_ACTUALIZA_USUARIOAUTORIZA");
            }
            
        }  catch (Exception e) {
            log.error("ERROR EN actualizarEnCascada:"+e);
        }
        setMessageSuccess("Se actualizó la acción " + "'" + accion.getTxtAccion() + "'" + " en cascada satisfactoriamente.");
    }
     
    public void afterSaveAccion(ActionEvent event) throws Exception {
        //esNuevo = false;
        setMessageSuccess("Se creo la acción " + "'" + selectedAccion.getTxtAccion() + "'" + " satisfactoriamente.");
        log.info("End of Transaction: 'Save'");
    }
    
    public void afterUpdateAccion(ActionEvent event) throws Exception {
        setMessageSuccess("Se actualizó la acción " + "'" + selectedAccion.getTxtAccion() + "'" + " satisfactoriamente.");
        log.info("End of Transaction: 'Update'");
    }
    
    public boolean validateAccion() throws Exception {
        boolean success = true;
        
        if (selectedAccion.getTxtAccion() == null ){
            selectedAccion.setTxtAccion("");
        }
        if(selectedAccion.getTxtAccion().trim().equals("")) {
            setMessageError(new Exception("Se debe ingresar el nombre."));
            success = false;
            return success;
        }
        
        if (selectedAccion.getTxtNombreObjeto() == null ){
            selectedAccion.setTxtNombreObjeto("");
        }
        if(selectedAccion.getTxtNombreObjeto().trim().equals("")) {
            setMessageError(new Exception("Se debe ingresar el nombre del objeto."));
            success = false;
            return success;
        }
        return success;
    }

    public boolean isBVisible() {
        return BVisible;
    }

    public void setBVisible(boolean BVisible) {
        this.BVisible = BVisible;
    }
    
}  
